﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using System.IO;
using System.Drawing;

namespace GraphicLib
{
    public class ProcessThread
    {
        private static Dictionary<string, Thread> threads = new Dictionary<string, Thread>();//线程池

        //声明一个委托
        public delegate void SetTextBoxValue(TextBox txtLog, string logValue);

        public delegate void SetButtonEnable(Button btnStart, bool enable);

        public delegate void SetPictureBoxImage(PictureBox pictureBoxProduct, string productPath);

        public delegate void SetPanelColor(Panel panelResultColor, Color color);

        /// <summary>
        /// 开始一个处理进程
        /// </summary>
        /// <returns></returns>
        public void StartAProcessThread(TextBox textLog, Button btnStart, PictureBox pictureBoxProduct, Panel panelResultColor)
        {
            ParameterizedThreadStart threadStart = new ParameterizedThreadStart(Process);

            Thread thread = new Thread(threadStart);
            string threadName = Guid.NewGuid().ToString(); //为当前线程取一个名字，结束时根据该名字从线程池移除线程
            thread.Name = threadName;
            thread.IsBackground = true;
            thread.Start(new List<Control>() { textLog, btnStart, pictureBoxProduct, panelResultColor });
            threads.Add(threadName, thread);
        }

        /// <summary>
        /// 从线程池移除一个线程
        /// </summary>
        /// <param name="thread"></param>
        public static void RemoveThread(Thread thread)
        {
            RemoveThread(thread.Name);
        }

        /// <summary>
        /// 从线程池移除一个线程
        /// </summary>
        /// <param name="thread"></param>
        public static void RemoveThread(string threadName)
        {
            threads.Remove(threadName);
        }

        /// <summary>
        /// 杀死线程池内的所有线程
        /// </summary>
        public static void KillAllThreads()
        {
            foreach (string threadName in threads.Keys)
            {
                Thread thread = threads[threadName];
                if (thread.IsAlive)
                {
                    thread.Abort();
                }
            }
            threads.Clear();
        }

        /// <summary>
        /// 挂起所有线程
        /// </summary>
        public static void SuspendAllThreads()
        {
            foreach (string threadName in threads.Keys)
            {
                threads[threadName].Suspend();
            }
        }

        /// <summary>
        /// 恢复所有线程
        /// </summary>
        public static void ResumeAllThreads()
        {
            foreach (string threadName in threads.Keys)
            {
                threads[threadName].Resume();
            }
        }

        private void Process(object objControls)
        {
            StringBuilder log = new StringBuilder();
            log.AppendFormat("---- {0} 开始产品检测 ----\r\n",DateTime.Now);
            List<Control> controls = (List<Control>) objControls;
            ProductCheck.CheckProducts((TextBox)controls[0], (Button)controls[1], (PictureBox)controls[2], (Panel)controls[3]);
            RemoveThread(Thread.CurrentThread);
            //OutPutLog(log, objLog);
        }

        //DEMO用，输出日志
        //private void OutPutLog(StringBuilder log, object objLog)
        //{
        //    string logFilePath = Sample.LOG_PATH;
        //    //以下为DEMO代码
        //    TextBox txtLog = (TextBox)objLog;
        //    //txtLog.AppendText(log.ToString()+"日志存储路径：" + logFilePath);
        //    SetMyTextBoxValue(log.ToString() + "日志存储路径：" + logFilePath, txtLog);
        //    File.AppendAllText(logFilePath, log.ToString() + "\r\n");

        //}

        //委托使用文本框
        public static void SetMyTextBoxValue(TextBox txtLog, string logValue)
        {
            // Control.InvokeRequired 属性： 获取一个值，该值指示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。当前线程不是创建控件的线程时为true,当前线程中访问是False
            if (txtLog.InvokeRequired)
            {
                GraphicLib.ProcessThread.SetTextBoxValue objSetTextBoxValue = new GraphicLib.ProcessThread.SetTextBoxValue(SetMyTextBoxValue);

                // IAsyncResult 接口：表示异步操作的状态。不同的异步操作需要不同的类型来描述，自然可以返回任何对象。
                // Control.BeginInvoke 方法 (Delegate)：在创建控件的基础句柄所在线程上异步执行指定委托。
                IAsyncResult result = txtLog.BeginInvoke(objSetTextBoxValue, txtLog, logValue);
                try
                {
                    objSetTextBoxValue.EndInvoke(result);
                }
                catch
                {
                }
            }
            else
            {
                txtLog.Text += logValue + Environment.NewLine;
                txtLog.SelectionStart = txtLog.TextLength;
                txtLog.ScrollToCaret();
            }
        }

        public static void SetMyButtonEnable(Button btnStart, bool enable)
        {
            // Control.InvokeRequired 属性： 获取一个值，该值指示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。当前线程不是创建控件的线程时为true,当前线程中访问是False
            if (btnStart.InvokeRequired)
            {
                GraphicLib.ProcessThread.SetButtonEnable objSetMyButtonEnable = new GraphicLib.ProcessThread.SetButtonEnable(SetMyButtonEnable);

                // IAsyncResult 接口：表示异步操作的状态。不同的异步操作需要不同的类型来描述，自然可以返回任何对象。
                // Control.BeginInvoke 方法 (Delegate)：在创建控件的基础句柄所在线程上异步执行指定委托。
                IAsyncResult result = btnStart.BeginInvoke(objSetMyButtonEnable, btnStart, enable);
                try
                {
                    objSetMyButtonEnable.EndInvoke(result);
                }
                catch
                {
                }
            }
            else
            {
                btnStart.Enabled = enable;
            }
        }

        public static void SetMyPictureBoxImage(PictureBox pictureBoxProduct, string productPath)
        {
            // Control.InvokeRequired 属性： 获取一个值，该值指示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。当前线程不是创建控件的线程时为true,当前线程中访问是False
            if (pictureBoxProduct.InvokeRequired)
            {
                GraphicLib.ProcessThread.SetPictureBoxImage objSetMyPictureBoxImage = new GraphicLib.ProcessThread.SetPictureBoxImage(SetMyPictureBoxImage);

                // IAsyncResult 接口：表示异步操作的状态。不同的异步操作需要不同的类型来描述，自然可以返回任何对象。
                // Control.BeginInvoke 方法 (Delegate)：在创建控件的基础句柄所在线程上异步执行指定委托。
                IAsyncResult result = pictureBoxProduct.BeginInvoke(objSetMyPictureBoxImage, pictureBoxProduct, productPath);
                try
                {
                    objSetMyPictureBoxImage.EndInvoke(result);
                }
                catch
                {
                }
            }
            else
            {
                pictureBoxProduct.LoadAsync(productPath);
            }
        }

        public static void SetMyPanelColor(Panel panelResultColor, Color color)
        {
            // Control.InvokeRequired 属性： 获取一个值，该值指示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。当前线程不是创建控件的线程时为true,当前线程中访问是False
            if (panelResultColor.InvokeRequired)
            {
                GraphicLib.ProcessThread.SetPanelColor objSetMyPanelColor = new GraphicLib.ProcessThread.SetPanelColor(SetMyPanelColor);

                // IAsyncResult 接口：表示异步操作的状态。不同的异步操作需要不同的类型来描述，自然可以返回任何对象。
                // Control.BeginInvoke 方法 (Delegate)：在创建控件的基础句柄所在线程上异步执行指定委托。
                IAsyncResult result = panelResultColor.BeginInvoke(objSetMyPanelColor, panelResultColor, color);
                try
                {
                    objSetMyPanelColor.EndInvoke(result);
                }
                catch
                {
                }
            }
            else
            {
                panelResultColor.BackColor = color;
            }
        }
    }
}
